home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / Interfaces&Libraries / Universal / Interfaces / PInterfaces / MoviesFormat.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  17.8 KB  |  640 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        MoviesFormat.p
  3.  
  4.      Contains:    QuickTime Interfaces.
  5.  
  6.      Version:    Technology:    QuickTime 3.0
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1990-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT MoviesFormat;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __MOVIESFORMAT__}
  27. {$SETC __MOVIESFORMAT__ := 1}
  28.  
  29. {$I+}
  30. {$SETC MoviesFormatIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __MACTYPES__}
  34. {$I MacTypes.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __MOVIES__}
  37. {$I Movies.p}
  38. {$ENDC}
  39.  
  40.  
  41. {$PUSH}
  42. {$ALIGN MAC68K}
  43. {$LibExport+}
  44.  
  45.  
  46. CONST
  47.     kMovieVersion                = 0;                            {  version number of the format here described  }
  48.  
  49. {***************************************
  50. *
  51. *   General Types -
  52. *        These types are used in more than one of the
  53. *        directory types.
  54. *
  55. ***************************************}
  56. { MoviesUserData is the type used for user data in movie and track directories }
  57.  
  58. TYPE
  59.     MoviesUserDataPtr = ^MoviesUserData;
  60.     MoviesUserData = RECORD
  61.         size:                    LONGINT;                                {  size of this user data  }
  62.         udType:                    LONGINT;                                {  type of user data  }
  63.         data:                    SInt8;                                    {  the user data  }
  64.     END;
  65.  
  66.     UserDataAtomPtr = ^UserDataAtom;
  67.     UserDataAtom = RECORD
  68.         size:                    LONGINT;
  69.         atomType:                LONGINT;
  70.         userData:                ARRAY [0..0] OF MoviesUserData;
  71.     END;
  72.  
  73. { MoviesDataDescription tells us where the data for the movie or track lives.
  74.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  75.    be in the resource fork of the same file as the directory resource, be in another file in the
  76.    data fork or resource fork, or require a specific bottleneck to fetch the data. }
  77. {***************************************
  78. *
  79. *   MediaDirectory information -
  80. *        The MediaDirectory is tightly coupled to the data.
  81. *
  82. ***************************************}
  83.  
  84.     SampleDescriptionAtomPtr = ^SampleDescriptionAtom;
  85.     SampleDescriptionAtom = RECORD
  86.         size:                    LONGINT;
  87.         atomType:                LONGINT;                                {  = 'stsd'  }
  88.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  89.         numEntries:                LONGINT;
  90.         sampleDescTable:        ARRAY [0..0] OF SampleDescription;
  91.     END;
  92.  
  93. { TimeToSampleNum maps physical sample time to physical sample number. }
  94.     TimeToSampleNumPtr = ^TimeToSampleNum;
  95.     TimeToSampleNum = RECORD
  96.         sampleCount:            LONGINT;
  97.         sampleDuration:            TimeValue;
  98.     END;
  99.  
  100.     TimeToSampleNumAtomPtr = ^TimeToSampleNumAtom;
  101.     TimeToSampleNumAtom = RECORD
  102.         size:                    LONGINT;
  103.         atomType:                LONGINT;                                {  = 'stts'  }
  104.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  105.         numEntries:                LONGINT;
  106.         timeToSampleNumTable:    ARRAY [0..0] OF TimeToSampleNum;
  107.     END;
  108.  
  109. { SyncSamples is a list of the physical samples which are self contained. }
  110.     SyncSampleAtomPtr = ^SyncSampleAtom;
  111.     SyncSampleAtom = RECORD
  112.         size:                    LONGINT;
  113.         atomType:                LONGINT;                                {  = 'stss'  }
  114.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  115.         numEntries:                LONGINT;
  116.         syncSampleTable:        ARRAY [0..0] OF LONGINT;
  117.     END;
  118.  
  119. { SampleToChunk maps physical sample number to chunk number. }
  120. { same as SampleToChunk, but redundant first sample is removed }
  121.     SampleToChunkPtr = ^SampleToChunk;
  122.     SampleToChunk = RECORD
  123.         firstChunk:                LONGINT;
  124.         samplesPerChunk:        LONGINT;
  125.         sampleDescriptionID:    LONGINT;
  126.     END;
  127.  
  128.     SampleToChunkAtomPtr = ^SampleToChunkAtom;
  129.     SampleToChunkAtom = RECORD
  130.         size:                    LONGINT;
  131.         atomType:                LONGINT;                                {  = 'stsc'  }
  132.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  133.         numEntries:                LONGINT;
  134.         sampleToChunkTable:        ARRAY [0..0] OF SampleToChunk;
  135.     END;
  136.  
  137.     ChunkOffsetAtomPtr = ^ChunkOffsetAtom;
  138.     ChunkOffsetAtom = RECORD
  139.         size:                    LONGINT;
  140.         atomType:                LONGINT;                                {  = 'stco'  }
  141.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  142.         numEntries:                LONGINT;
  143.         chunkOffsetTable:        ARRAY [0..0] OF LONGINT;
  144.     END;
  145.  
  146.     SampleSizeAtomPtr = ^SampleSizeAtom;
  147.     SampleSizeAtom = RECORD
  148.         size:                    LONGINT;
  149.         atomType:                LONGINT;                                {  = 'stsz'  }
  150.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  151.         sampleSize:                LONGINT;
  152.         numEntries:                LONGINT;
  153.         sampleSizeTable:        ARRAY [0..0] OF LONGINT;
  154.     END;
  155.  
  156.     ShadowSyncPtr = ^ShadowSync;
  157.     ShadowSync = RECORD
  158.         fdSampleNum:            LONGINT;
  159.         syncSampleNum:            LONGINT;
  160.     END;
  161.  
  162.     ShadowSyncAtomPtr = ^ShadowSyncAtom;
  163.     ShadowSyncAtom = RECORD
  164.         size:                    LONGINT;
  165.         atomType:                LONGINT;                                {  = 'stsz'  }
  166.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  167.         numEntries:                LONGINT;
  168.         shadowSyncTable:        ARRAY [0..0] OF ShadowSync;
  169.     END;
  170.  
  171.     SampleTableAtomPtr = ^SampleTableAtom;
  172.     SampleTableAtom = RECORD
  173.         size:                    LONGINT;
  174.         atomType:                LONGINT;                                {  = 'stbl'  }
  175.         sampleDescription:        SampleDescriptionAtom;
  176.         timeToSampleNum:        TimeToSampleNumAtom;
  177.         sampleToChunk:            SampleToChunkAtom;
  178.         syncSample:                SyncSampleAtom;
  179.         sampleSize:                SampleSizeAtom;
  180.         chunkOffset:            ChunkOffsetAtom;
  181.         shadowSync:                ShadowSyncAtom;
  182.     END;
  183.  
  184.     PublicHandlerInfoPtr = ^PublicHandlerInfo;
  185.     PublicHandlerInfo = RECORD
  186.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  187.         componentType:            LONGINT;
  188.         componentSubType:        LONGINT;
  189.         componentManufacturer:    LONGINT;
  190.         componentFlags:            LONGINT;
  191.         componentFlagsMask:        LONGINT;
  192.         componentName:            SInt8;
  193.     END;
  194.  
  195.     HandlerAtomPtr = ^HandlerAtom;
  196.     HandlerAtom = RECORD
  197.         size:                    LONGINT;
  198.         atomType:                LONGINT;                                {  = 'hdlr'  }
  199.         hInfo:                    PublicHandlerInfo;
  200.     END;
  201.  
  202. { a data reference is a private structure }
  203.     DataRefAtom                            = LONGINT;
  204.     DataInfoAtomPtr = ^DataInfoAtom;
  205.     DataInfoAtom = RECORD
  206.         size:                    LONGINT;
  207.         atomType:                LONGINT;                                {  = 'dinf'  }
  208.         dataRef:                DataRefAtom;
  209.     END;
  210.  
  211.     RgnAtomPtr = ^RgnAtom;
  212.     RgnAtom = RECORD
  213.         size:                    LONGINT;
  214.         atomType:                LONGINT;
  215.         rgnSize:                INTEGER;
  216.         rgnBBox:                Rect;
  217.         data:                    SInt8;
  218.     END;
  219.  
  220.     MatteCompressedAtomPtr = ^MatteCompressedAtom;
  221.     MatteCompressedAtom = RECORD
  222.         size:                    LONGINT;
  223.         atomType:                LONGINT;
  224.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  225.         matteImageDescription:    ImageDescription;
  226.         matteData:                SInt8;
  227.     END;
  228.  
  229.     MatteAtomPtr = ^MatteAtom;
  230.     MatteAtom = RECORD
  231.         size:                    LONGINT;
  232.         atomType:                LONGINT;
  233.         aCompressedMatte:        MatteCompressedAtom;
  234.     END;
  235.  
  236.     ClippingAtomPtr = ^ClippingAtom;
  237.     ClippingAtom = RECORD
  238.         size:                    LONGINT;
  239.         atomType:                LONGINT;
  240.         aRgnClip:                RgnAtom;
  241.     END;
  242.  
  243. {**********************
  244. * Media Info Example Structures
  245. **********************}
  246.  
  247.     VideoMediaInfoHeaderPtr = ^VideoMediaInfoHeader;
  248.     VideoMediaInfoHeader = RECORD
  249.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  250.         graphicsMode:            INTEGER;                                {  for QD - transfer mode  }
  251.         opColorRed:                INTEGER;                                {  opcolor for transfer mode  }
  252.         opColorGreen:            INTEGER;
  253.         opColorBlue:            INTEGER;
  254.     END;
  255.  
  256.     VideoMediaInfoHeaderAtomPtr = ^VideoMediaInfoHeaderAtom;
  257.     VideoMediaInfoHeaderAtom = RECORD
  258.         size:                    LONGINT;                                {  size of Media info  }
  259.         atomType:                LONGINT;                                {  = 'vmhd'  }
  260.         vmiHeader:                VideoMediaInfoHeader;
  261.     END;
  262.  
  263.     VideoMediaInfoPtr = ^VideoMediaInfo;
  264.     VideoMediaInfo = RECORD
  265.         size:                    LONGINT;                                {  size of Media info  }
  266.         atomType:                LONGINT;                                {  = 'minf'  }
  267.         header:                    VideoMediaInfoHeaderAtom;
  268.         dataHandler:            HandlerAtom;
  269.         dataInfo:                DataInfoAtom;
  270.         sampleTable:            SampleTableAtom;
  271.     END;
  272.  
  273.     SoundMediaInfoHeaderPtr = ^SoundMediaInfoHeader;
  274.     SoundMediaInfoHeader = RECORD
  275.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  276.         balance:                INTEGER;
  277.         rsrvd:                    INTEGER;
  278.     END;
  279.  
  280.     SoundMediaInfoHeaderAtomPtr = ^SoundMediaInfoHeaderAtom;
  281.     SoundMediaInfoHeaderAtom = RECORD
  282.         size:                    LONGINT;                                {  size of Media info  }
  283.         atomType:                LONGINT;                                {  = 'vmhd'  }
  284.         smiHeader:                SoundMediaInfoHeader;
  285.     END;
  286.  
  287.     SoundMediaInfoPtr = ^SoundMediaInfo;
  288.     SoundMediaInfo = RECORD
  289.         size:                    LONGINT;                                {  size of Media info  }
  290.         atomType:                LONGINT;                                {  = 'minf'  }
  291.         header:                    SoundMediaInfoHeaderAtom;
  292.         dataHandler:            HandlerAtom;
  293.         dataReference:            DataRefAtom;
  294.         sampleTable:            SampleTableAtom;
  295.     END;
  296.  
  297. { whatever data the media handler needs goes after the atomType }
  298.     MediaInfoPtr = ^MediaInfo;
  299.     MediaInfo = RECORD
  300.         size:                    LONGINT;
  301.         atomType:                LONGINT;
  302.     END;
  303.  
  304. {**********************
  305. * Media Directory Structures
  306. **********************}
  307.     MediaHeaderPtr = ^MediaHeader;
  308.     MediaHeader = RECORD
  309.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  310.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  311.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  312.         timeScale:                TimeValue;                                {  start time for Media (Media time)  }
  313.         duration:                TimeValue;                                {  length of Media (Media time)  }
  314.         language:                INTEGER;
  315.         quality:                INTEGER;
  316.     END;
  317.  
  318.     MediaHeaderAtomPtr = ^MediaHeaderAtom;
  319.     MediaHeaderAtom = RECORD
  320.         size:                    LONGINT;
  321.         atomType:                LONGINT;
  322.         header:                    MediaHeader;
  323.     END;
  324.  
  325.     MediaDirectoryPtr = ^MediaDirectory;
  326.     MediaDirectory = RECORD
  327.         size:                    LONGINT;
  328.         atomType:                LONGINT;                                {  = 'mdia'  }
  329.         mediaHeader:            MediaHeaderAtom;                        {  standard Media information  }
  330.         mediaHandler:            HandlerAtom;
  331.         mediaInfo:                MediaInfo;
  332.     END;
  333.  
  334. {**********************
  335. * Track Structures
  336. **********************}
  337.  
  338. CONST
  339.     TrackEnable                    = $01;
  340.     TrackInMovie                = $02;
  341.     TrackInPreview                = $04;
  342.     TrackInPoster                = $08;
  343.  
  344.  
  345. TYPE
  346.     TrackHeaderPtr = ^TrackHeader;
  347.     TrackHeader = RECORD
  348.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  349.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  350.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  351.         trackID:                LONGINT;
  352.         reserved1:                LONGINT;
  353.         duration:                TimeValue;                                {  length of track (track time)  }
  354.         reserved2:                LONGINT;
  355.         reserved3:                LONGINT;
  356.         layer:                    INTEGER;
  357.         alternateGroup:            INTEGER;
  358.         volume:                    INTEGER;
  359.         reserved4:                INTEGER;
  360.         matrix:                    MatrixRecord;
  361.         trackWidth:                Fixed;
  362.         trackHeight:            Fixed;
  363.     END;
  364.  
  365.     TrackHeaderAtomPtr = ^TrackHeaderAtom;
  366.     TrackHeaderAtom = RECORD
  367.         size:                    LONGINT;                                {  size of track header  }
  368.         atomType:                LONGINT;                                {  = 'tkhd'  }
  369.         header:                    TrackHeader;
  370.     END;
  371.  
  372.     EditListTypePtr = ^EditListType;
  373.     EditListType = RECORD
  374.         trackDuration:            TimeValue;
  375.         mediaTime:                TimeValue;
  376.         mediaRate:                Fixed;
  377.     END;
  378.  
  379.     EditListAtomPtr = ^EditListAtom;
  380.     EditListAtom = RECORD
  381.         size:                    LONGINT;
  382.         atomType:                LONGINT;                                {  = elst  }
  383.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  384.         numEntries:                LONGINT;
  385.         editListTable:            ARRAY [0..0] OF EditListType;
  386.     END;
  387.  
  388.     EditsAtomPtr = ^EditsAtom;
  389.     EditsAtom = RECORD
  390.         size:                    LONGINT;
  391.         atomType:                LONGINT;                                {  = edts  }
  392.         editList:                EditListAtom;
  393.     END;
  394.  
  395.     TrackLoadSettingsPtr = ^TrackLoadSettings;
  396.     TrackLoadSettings = RECORD
  397.         preloadStartTime:        TimeValue;
  398.         preloadDuration:        TimeValue;
  399.         preloadFlags:            LONGINT;
  400.         defaultHints:            LONGINT;
  401.     END;
  402.  
  403.     TrackLoadSettingsAtomPtr = ^TrackLoadSettingsAtom;
  404.     TrackLoadSettingsAtom = RECORD
  405.         size:                    LONGINT;
  406.         atomType:                LONGINT;                                {  = load  }
  407.         settings:                TrackLoadSettings;
  408.     END;
  409.  
  410.     TrackDirectoryPtr = ^TrackDirectory;
  411.     TrackDirectory = RECORD
  412.         size:                    LONGINT;
  413.         atomType:                LONGINT;                                {  = 'trak'  }
  414.         trackHeader:            TrackHeaderAtom;                        {  standard track information  }
  415.         trackClip:                ClippingAtom;
  416.         edits:                    EditsAtom;
  417.         media:                    MediaDirectory;
  418.         userData:                UserDataAtom;                            {  space for extending with new data types  }
  419.     END;
  420.  
  421. {***************************************
  422. *
  423. *   MovieDirectory -
  424. *        The MovieDirectory is the top level structure which
  425. *        holds the TrackInstance describing where the
  426. *        TrackDirectories are.
  427. *
  428. ***************************************}
  429.     MovieHeaderPtr = ^MovieHeader;
  430.     MovieHeader = RECORD
  431.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  432.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  433.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  434.         timeScale:                TimeValue;                                {  Time specifications  }
  435.         duration:                TimeValue;
  436.         preferredRate:            Fixed;                                    {  rate at which to play this movie  }
  437.         preferredVolume:        INTEGER;                                {  volume to play movie at  }
  438.         reserved1:                INTEGER;
  439.         preferredLong1:            LONGINT;
  440.         preferredLong2:            LONGINT;
  441.         matrix:                    MatrixRecord;
  442.         previewTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  443.         previewDuration:        TimeValue;                                {  how long the proxy lasts (track time)  }
  444.         posterTime:                TimeValue;                                {  time in track the proxy begins (track time)  }
  445.         selectionTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  446.         selectionDuration:        TimeValue;                                {  time in track the proxy begins (track time)  }
  447.         currentTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  448.         nextTrackID:            LONGINT;                                {  next value to use for a TrackID  }
  449.     END;
  450.  
  451.     MovieHeaderAtomPtr = ^MovieHeaderAtom;
  452.     MovieHeaderAtom = RECORD
  453.         size:                    LONGINT;
  454.         atomType:                LONGINT;                                {  = 'mvhd'  }
  455.         header:                    MovieHeader;
  456.     END;
  457.  
  458.     TrackDirectoryEntryPtr = ^TrackDirectoryEntry;
  459.     TrackDirectoryEntry = RECORD
  460.         trackDirectory:            TrackDirectory;                            {  Track directory information  }
  461.     END;
  462.  
  463.     MovieDirectoryPtr = ^MovieDirectory;
  464.     MovieDirectory = RECORD
  465.         size:                    LONGINT;
  466.         atomType:                LONGINT;                                {  = 'moov'  }
  467.         header:                    MovieHeaderAtom;
  468.         movieClip:                ClippingAtom;
  469.                                                                         {  Track Directories  }
  470.         track:                    ARRAY [0..0] OF TrackDirectoryEntry;    {  Track directory information  }
  471.                                                                         {  User data for Movie  }
  472.         userData:                UserDataAtom;                            {  space for user extensions  }
  473.     END;
  474.  
  475. {***************************************
  476. ***************************************}
  477.  
  478. { Movie formats and tags }
  479.  
  480. CONST
  481.                                                                 {  some system defined format IDs  }
  482.     MOVIE_TYPE                    = 'moov';
  483.     TRACK_TYPE                    = 'trak';
  484.     MEDIA_TYPE                    = 'mdia';
  485.     VIDEO_TYPE                    = 'vide';
  486.     SOUND_TYPE                    = 'soun';
  487.  
  488. { atom id's }
  489.     MovieAID                    = 'moov';
  490.     MovieHeaderAID                = 'mvhd';
  491.     ClipAID                        = 'clip';
  492.     RgnClipAID                    = 'crgn';
  493.     MatteAID                    = 'matt';
  494.     MatteCompAID                = 'kmat';
  495.     TrackAID                    = 'trak';
  496.     UserDataAID                    = 'udta';
  497.     TrackHeaderAID                = 'tkhd';
  498.     EditsAID                    = 'edts';
  499.     EditListAID                    = 'elst';
  500.     MediaAID                    = 'mdia';
  501.     MediaHeaderAID                = 'mdhd';
  502.     MediaInfoAID                = 'minf';
  503.     VideoMediaInfoHeaderAID        = 'vmhd';
  504.     SoundMediaInfoHeaderAID        = 'smhd';
  505.     GenericMediaInfoHeaderAID    = 'gmhd';
  506.     GenericMediaInfoAID            = 'gmin';
  507.     DataInfoAID                    = 'dinf';
  508.     DataRefAID                    = 'dref';
  509.     SampleTableAID                = 'stbl';
  510.     STSampleDescAID                = 'stsd';
  511.     STTimeToSampAID                = 'stts';
  512.     STSyncSampleAID                = 'stss';
  513.     STSampleToChunkAID            = 'stsc';
  514.     STShadowSyncAID                = 'stsh';
  515.     HandlerAID                    = 'hdlr';
  516.     STSampleSizeAID                = 'stsz';
  517.     STChunkOffsetAID            = 'stco';
  518.     STChunkOffset64AID            = 'co64';
  519.     STSampleIDAID                = 'stid';
  520.     DataRefContainerAID            = 'drfc';
  521.     TrackReferenceAID            = 'tref';
  522.     ColorTableAID                = 'ctab';
  523.     LoadSettingsAID                = 'load';
  524.     PropertyAtomAID                = 'code';
  525.     InputMapAID                    = 'imap';
  526.     MovieBufferHintsAID            = 'mbfh';
  527.     MovieDataRefAliasAID        = 'mdra';
  528.     SoundLocalizationAID        = 'sloc';
  529.     CompressedMovieAID            = 'cmov';
  530.     CompressedMovieDataAID        = 'cmvd';
  531.     DataCompressionAtomAID        = 'dcom';
  532.     ReferenceMovieRecordAID        = 'rmra';
  533.     ReferenceMovieDescriptorAID    = 'rmda';
  534.     ReferenceMovieDataRefAID    = 'rdrf';
  535.     ReferenceMovieVersionCheckAID = 'rmvc';
  536.     ReferenceMovieDataRateAID    = 'rmdr';
  537.     ReferenceMovieComponentCheckAID = 'rmcd';
  538.     ReferenceMovieQualityAID    = 'rmqu';
  539.  
  540. {  Text ATOM definitions }
  541.  
  542.  
  543. TYPE
  544.     TextBoxAtomPtr = ^TextBoxAtom;
  545.     TextBoxAtom = RECORD
  546.         size:                    LONGINT;
  547.         atomType:                LONGINT;                                {  = 'tbox'  }
  548.         textBox:                Rect;                                    {  New text box (overrides defaultTextBox) }
  549.     END;
  550.  
  551.     HiliteAtomPtr = ^HiliteAtom;
  552.     HiliteAtom = RECORD
  553.         size:                    LONGINT;
  554.         atomType:                LONGINT;                                {  = 'hlit'  }
  555.         selStart:                LONGINT;                                {  hilite selection start character }
  556.         selEnd:                    LONGINT;                                {  hilite selection end character }
  557.     END;
  558.  
  559.     KaraokeRecPtr = ^KaraokeRec;
  560.     KaraokeRec = RECORD
  561.         timeVal:                TimeValue;
  562.         beginHilite:            INTEGER;
  563.         endHilite:                INTEGER;
  564.     END;
  565.  
  566.     KaraokeAtomPtr = ^KaraokeAtom;
  567.     KaraokeAtom = RECORD
  568.         numEntries:                LONGINT;
  569.         karaokeEntries:            ARRAY [0..0] OF KaraokeRec;
  570.     END;
  571.  
  572. {  for ReferenceMovieDataRefRecord.flags }
  573.  
  574. CONST
  575.     kDataRefIsSelfContained        = $01;
  576.  
  577.  
  578. TYPE
  579.     ReferenceMovieDataRefRecordPtr = ^ReferenceMovieDataRefRecord;
  580.     ReferenceMovieDataRefRecord = RECORD
  581.         flags:                    LONGINT;
  582.         dataRefType:            OSType;
  583.         dataRefSize:            LONGINT;
  584.         dataRef:                SInt8;
  585.     END;
  586.  
  587. {  for VersionCheckRecord.checkType }
  588.  
  589. CONST
  590.     kVersionCheckMin            = 0;                            {  val1 is the min. version required }
  591.     kVersionCheckMask            = 1;                            {  (gestalt return value & val2) must == val1 }
  592.  
  593.  
  594. TYPE
  595.     QTAltVersionCheckRecordPtr = ^QTAltVersionCheckRecord;
  596.     QTAltVersionCheckRecord = RECORD
  597.         flags:                    LONGINT;                                {  currently always 0 }
  598.         gestaltTag:                OSType;
  599.         val1:                    UInt32;
  600.         val2:                    UInt32;
  601.         checkType:                INTEGER;
  602.     END;
  603.  
  604. {  some helpful constants for DataRateRecord.dataRate  }
  605.  
  606. CONST
  607.     kDataRate144ModemRate        = 1400;
  608.     kDataRate288ModemRate        = 2800;
  609.     kDataRateISDNRate            = 5600;
  610.     kDataRateDualISDNRate        = 11200;
  611.     kDataRateT1Rate                = 150000;
  612.     kDataRateInfiniteRate        = $7FFFFFFF;
  613.  
  614.  
  615. TYPE
  616.     QTAltDataRateRecordPtr = ^QTAltDataRateRecord;
  617.     QTAltDataRateRecord = RECORD
  618.         flags:                    LONGINT;                                {  currently always 0 }
  619.         dataRate:                LONGINT;
  620.     END;
  621.  
  622.     QTAltComponentCheckRecordPtr = ^QTAltComponentCheckRecord;
  623.     QTAltComponentCheckRecord = RECORD
  624.         flags:                    LONGINT;                                {  currently always 0  }
  625.         cd:                        ComponentDescription;
  626.         minVersion:                UInt32;
  627.     END;
  628.  
  629.  
  630. {$ALIGN RESET}
  631. {$POP}
  632.  
  633. {$SETC UsingIncludes := MoviesFormatIncludes}
  634.  
  635. {$ENDC} {__MOVIESFORMAT__}
  636.  
  637. {$IFC NOT UsingIncludes}
  638.  END.
  639. {$ENDC}
  640.